package com.fdb.efp.nls.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fdb.efp.nls.common.constant.*;
import com.fdb.efp.nls.service.facade.NlsApplyInfoService;
import com.fdb.efp.nls.service.facade.NlsQueueSoltComnService;
import com.fdb.efp.nls.service.facade.SoltService;
import com.fdb.efp.nls.service.facade.UpdateLmtPrdContService;
import com.fdb.efp.nls.service.facade.queue.NlsProcessBizService;
import com.fdb.efp.nls.service.facade.queue.NlsProcessRuleService;
import com.fdb.efp.nls.service.facade.queue.NlsQueueTaskService;
import com.fdb.efp.nls.service.vo.NlsApplyInfoVO;
import com.fdb.efp.nls.service.vo.queue.NlsProcessBizVO;
import com.fdb.efp.nls.service.vo.queue.NlsProcessRuleVO;
import com.fdb.basic.framework.core.exception.BizException;
import com.fdb.basic.framework.core.exception.HangException;
import com.fdb.basic.framework.core.exception.QueuePauseException;
import com.fdb.basic.framework.core.util.DateUtility;
import com.fdb.efp.basic.framework.mq.client.producer.MQProducerMessageClient;
import com.fdb.efp.basic.framework.mq.constant.TagEnums;
import com.fdb.efp.basic.framework.mq.constant.TopicEnums;
import com.fdb.efp.nls.common.PrdBizEnums;
import com.fdb.efp.esb.common.constant.MsLoanConstant;
import com.fdb.efp.esb.service.bo.req.MsLoanReq;
import com.fdb.efp.esb.service.bo.req.yx.LetterBasicInfo;
import com.fdb.efp.esb.service.bo.req.yx.LetterExpanding;
import com.fdb.efp.esb.service.bo.req.yx.LetterMessage;
import com.fdb.efp.esb.service.bo.req.yx.LetterReq;
import com.fdb.efp.esb.service.facade.MsLoanService;
import com.fdb.efp.esb.service.facade.yx.LetterService;
import com.fdb.efp.nls.common.exception.LoanReleaseException;
import com.fdb.efp.nls.common.exception.LoanRepaySyncException;
import org.apache.rocketmq.common.message.Message;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

import java.lang.reflect.Method;
import java.util.Date;

import static com.fdb.efp.nls.common.constant.psd.NlsApplyFlowStatus.FLOW_STATUS_5;
import static com.fdb.efp.nls.common.constant.psd.NlsApplyFlowStatus.FLOW_STATUS_8;

/**
 * 队列插槽服务实现类
 *
 * diff-msg:普税贷修改，评估无影响
 *
 * @author huangwb
 * @since 2019年1月4日 下午5:32:02
 * @version 1.0
 */
public abstract class SoltServiceImpl implements SoltService {
	private static Logger logger = LoggerFactory.getLogger(SoltServiceImpl.class);

	/**
	 * 队列插槽服务实现方法
	 *
	 * @param nlsQueueEventVO
	 *            队列事件
	 * @throws HangException
	 * @throws BizException
	 * @throws Exception
	 * @author huangwb
	 * @since 2019年1月4日 下午5:48:22
	 * @version 1.0
	 */
	@Override
	public void execute(NlsProcessBizVO nlsProcessBizVo, NlsApplyInfoVO nlsApplyInfoVO, int soltOrder) throws HangException, BizException, Exception {
		// 预处理
		String applySeq = nlsProcessBizVo.getApplySeq();
		String soltCode = nlsProcessBizVo.getSoltCode();
		String soltName = nlsProcessBizVo.getSoltName();
		String soltService = nlsProcessBizVo.getSoltService();
		logger.info("*********************************************");
		logger.info("*            开始一个新的插槽                 * ");
		logger.info("* 申请流水号 : 【" + applySeq + "】  *");
		logger.info("* 插槽代码 : 【" + soltCode + "】  *");
		logger.info("* 插槽名称 : 【" + soltName + "】  *");
		logger.info("* 插槽服务 : 【" + soltService + "】  *");
		logger.info("*********************************************");
		try {
			// 根据插槽代码 映射
			Method methodSoltstate = nlsProcessBizVo.getClass().getMethod("setSoltState" + soltOrder, String.class);
			// 更新该插槽状态为执行中
			logger.info("申请流水号 : 【" + applySeq + "】  更新该插槽状态为执行中开始");
			methodSoltstate.invoke(nlsProcessBizVo, PrdAdaptedSoltEnums.SoltProcessStateEnum.EXECUTING.getCode());
			//nlsProcessBizService.updateByPk(nlsProcessBizVo);
			logger.info("申请流水号 : 【" + applySeq + "】  更新该插槽状态为执行中结束");
			logger.info("申请流水号 : 【" + applySeq + "】  调用该插槽的业务逻辑处理开始");
			this.doExecute(nlsProcessBizVo, nlsApplyInfoVO);
			logger.info("申请流水号 : 【" + applySeq + "】  调用该插槽的业务逻辑处理结束");

			boolean exceptionFlag = nlsProcessBizVo.isExceptionFlag();
			int hangTimes = nlsProcessBizVo.getHangTimes();
			logger.info("申请流水号 : 【" + applySeq + "】  根据异常标志【" + exceptionFlag + "】处理后续网贷任务队列信息");
			// 异常处理，执行以上服务完成后更新【 网贷业务过程 】中对应的插槽状态
			if (exceptionFlag) {
				Exception exception = nlsProcessBizVo.getExceptionMsg();
				logger.info("申请流水号 : 【" + applySeq + "】 根据异常【" + exception + "】处理后续网贷任务队列信息");

				/** 查询规则过程信息 **/
				NlsProcessRuleVO nlsProcessRuleVO = new NlsProcessRuleVO();
				nlsProcessRuleVO.setApplySeq(applySeq);
				nlsProcessRuleVO = nlsProcessRuleService.queryByPk(nlsProcessRuleVO);
				if (exception instanceof HangException) {
					logger.info("申请流水号 : 【" + applySeq + "】 处理该插槽的挂起异常开始");
					// 每次轮询队列任务表中挂起任务后再次触发挂起异常后，对挂起次数进行控制，如果大于等于三次直接失败
					hangTimes = hangTimes + 1;
					if (hangTimes > QueueTaskEnums.QueueHangTimesEnum.MAX.getTimes()) {
						logger.info("申请流水号 : 【" + applySeq + "】 异常类型为挂起异常时，该插槽挂起次数为：【" + hangTimes + "】，更新该插槽状态为失败，更新网贷任务队列中队列任务状态为执行失败， 更新申请进件信息中申请状态为拒绝开始");
						// 更新该插槽状态为失败
						methodSoltstate.invoke(nlsProcessBizVo, PrdAdaptedSoltEnums.SoltProcessStateEnum.FAILURE.getCode());
						nlsProcessBizVo.setHangTimes(hangTimes);
						nlsProcessBizVo.setQueueTaskState(QueueTaskEnums.QueueTaskStateEnum.FAILURE.getCode());
						/** 设置插槽结果信息 **/
						nlsApplyInfoVO.setSoltResultDetails(JSONObject.toJSONString(nlsProcessBizVo));
						/** 设置规则结果信息 **/
						nlsApplyInfoVO.setRuleResultDetails(JSONObject.toJSONString(nlsProcessRuleVO));
						/** 设置结果码 **/
						nlsApplyInfoVO.setRspCode(NlsProcessBizEnums.RspInfoEnum.HANG_MAX_TIMES.getRspCode());
						/** 设置结果信息 **/
						nlsApplyInfoVO.setRspMsg(NlsProcessBizEnums.RspInfoEnum.HANG_MAX_TIMES.getRspMsg());
						/** 设置审批状态信息为失败 **/
						nlsApplyInfoVO.setNlsApplyState(MsLoanConstant.NlsApplyStateEnum.REJECT.getVALUE());
						logger.info("申请流水号 : 【" + applySeq + "】 异常类型为挂起异常时，该插槽挂起次数为：【" + hangTimes + "】，更新该插槽状态为失败，更新网贷任务队列中队列任务状态为执行失败， 更新申请进件信息中申请状态为拒绝结束");
						logger.info("申请流水号 : 【" + applySeq + "】执行 通知审批失败逻辑");
						// 通知审批失败
						noticeMSIfNecessary(nlsProcessBizVo,nlsApplyInfoVO);
					} else {
						/** 更新该插槽状态为挂起 **/
						logger.info("申请流水号 : 【" + applySeq + "】异常类型为挂起异常时更新该插槽状态为挂起，更新网贷任务队列中队列任务状态为挂起，更新 申请进件信息中申请状态为挂起");
						methodSoltstate.invoke(nlsProcessBizVo, PrdAdaptedSoltEnums.SoltProcessStateEnum.HANG.getCode());
						nlsProcessBizVo.setHangTimes(hangTimes);
						nlsProcessBizVo.setQueueTaskState(QueueTaskEnums.QueueTaskStateEnum.HANG.getCode());
						/** 设置插槽结果信息 **/
						nlsApplyInfoVO.setSoltResultDetails(JSONObject.toJSONString(nlsProcessBizVo));
						/** 设置规则结果信息 **/
						nlsApplyInfoVO.setRuleResultDetails(JSONObject.toJSONString(nlsProcessRuleVO));
						/** 设置结果码 **/
						nlsApplyInfoVO.setRspCode(NlsProcessBizEnums.RspInfoEnum.HANG.getRspCode());
						/** 设置结果信息 **/
						nlsApplyInfoVO.setRspMsg(NlsProcessBizEnums.RspInfoEnum.HANG.getRspMsg());
						/** 设置审批状态信息为挂起 **/
						nlsApplyInfoVO.setNlsApplyState(MsLoanConstant.NlsApplyStateEnum.HANG.getVALUE());
						
						/** 设置结果信息 **/
						nlsApplyInfoVO.setRefuseCause(exception.getMessage());

						nlsProcessBizVo.setLastModifyTime(DateUtility.getCurrAppDateTimeString());// 最近修改时间
						// 最近修改时间
						nlsApplyInfoVO.setLastModifyTime(DateUtility.getCurrAppDateTimeString());// 最近修改时间

						nlsProcessBizService.updateByPk(nlsProcessBizVo);
						nlsApplyInfoService.updateByPk(nlsApplyInfoVO);

						logger.info("申请流水号 : 【" + applySeq + "】处理该插槽的挂起异常结束");
						/** 发送MQ挂起消息 add by wangyk date:20190222 **/
						producerService.sendMsg(new Message(TopicEnums.QUEUE_TASK_HANG_TOPIC.getTopicId(), TagEnums.TAG_QUEUE_HANG_TASK.getTagId(), 
								nlsApplyInfoVO.getApplySeq().concat(".").concat(String.valueOf(hangTimes)),
								JSON.toJSONString(nlsApplyInfoVO).getBytes("UTF-8")),1);
						throw exception;
					}

				} else if (exception instanceof BizException) {
					logger.info("申请流水号 : 【" + applySeq + "】处理该插槽的业务异常开始，更新该插槽状态为失败， 更新网贷任务队列中队列任务状态为执行失败和更新 申请进件信息中申请状态为拒绝");
					// 更新该插槽状态为失败
					methodSoltstate.invoke(nlsProcessBizVo, PrdAdaptedSoltEnums.SoltProcessStateEnum.FAILURE.getCode());
					nlsProcessBizVo.setHangTimes(hangTimes);
					nlsProcessBizVo.setQueueTaskState(QueueTaskEnums.QueueTaskStateEnum.FAILURE.getCode());
					/** 设置插槽结果信息 **/
					nlsApplyInfoVO.setSoltResultDetails(JSONObject.toJSONString(nlsProcessBizVo));
					/** 设置规则结果信息 **/
					nlsApplyInfoVO.setRuleResultDetails(JSONObject.toJSONString(nlsProcessRuleVO));
					/** 设置结果码 **/
					nlsApplyInfoVO.setRspCode(NlsProcessBizEnums.RspInfoEnum.FAILURE.getRspCode());
					/** 设置结果信息 **/
					nlsApplyInfoVO.setRspMsg(NlsProcessBizEnums.RspInfoEnum.FAILURE.getRspMsg());
					/** 设置审批状态信息为失败 **/
					nlsApplyInfoVO.setNlsApplyState(MsLoanConstant.NlsApplyStateEnum.REJECT.getVALUE());
					// 通知审批失败
					noticeMSIfNecessary(nlsProcessBizVo,nlsApplyInfoVO);
					logger.info("申请流水号 : 【" + applySeq + "】处理该插槽的业务异常结束");
				} else if (exception instanceof QueuePauseException) {
					logger.info("申请流水号 : 【" + applySeq + "】异常类型为暂停异常时更新该插槽状态为暂停，更新网贷任务队列中队列任务状态为暂停，更新申请进件信息中申请状态为暂停");
					methodSoltstate.invoke(nlsProcessBizVo, PrdAdaptedSoltEnums.SoltProcessStateEnum.SUCCESS.getCode());
					nlsProcessBizVo.setQueueTaskState(QueueTaskEnums.QueueTaskStateEnum.SUCCESS.getCode());
					/** 设置插槽结果信息 **/
					nlsApplyInfoVO.setSoltResultDetails(JSONObject.toJSONString(nlsProcessBizVo));
					/** 设置规则结果信息 **/
					nlsApplyInfoVO.setRuleResultDetails(JSONObject.toJSONString(nlsProcessRuleVO));
					/** 设置结果码 **/
					nlsApplyInfoVO.setRspCode(NlsProcessBizEnums.RspInfoEnum.SUCCESS.getRspCode());
					/** 设置结果信息 **/
					nlsApplyInfoVO.setRspMsg(NlsProcessBizEnums.RspInfoEnum.SUCCESS.getRspMsg() + "。" + exception.getMessage());
					/** 设置审批状态信息为处理中 01 **/
					nlsApplyInfoVO.setNlsApplyState(NlsApplyInfoEnums.NlsApplyState.DEALING.getKey());
					/** 最近修改时间 **/
					nlsProcessBizVo.setLastModifyTime(DateUtility.getCurrAppDateTimeString());
					/** 最近修改时间 **/
					nlsApplyInfoVO.setLastModifyTime(DateUtility.getCurrAppDateTimeString());

					nlsProcessBizService.updateByPk(nlsProcessBizVo);
					nlsApplyInfoService.updateByPk(nlsApplyInfoVO);
					logger.info("申请流水号 : 【" + applySeq + "】处理该插槽的暂停异常结束");
				} else if (exception instanceof LoanReleaseException) {
					logger.info("申请流水号 : 【" + applySeq + "】 贷款开立发放执行失败,转为再放款补偿任务中执行");
					methodSoltstate.invoke(nlsProcessBizVo, PrdAdaptedSoltEnums.SoltProcessStateEnum.SUCCESS.getCode());
					nlsProcessBizVo.setQueueTaskState(QueueTaskEnums.QueueTaskStateEnum.SUCCESS.getCode());

					/** 设置插槽结果信息 **/
					nlsApplyInfoVO.setSoltResultDetails(JSONObject.toJSONString(nlsProcessBizVo));
					/** 设置规则结果信息 **/
					nlsApplyInfoVO.setRuleResultDetails(JSONObject.toJSONString(nlsProcessRuleVO));
					//设置结果码
					nlsApplyInfoVO.setRspCode(NlsProcessBizEnums.RspInfoEnum.SUCCESS.getRspCode());
					//设置结果信息
					nlsApplyInfoVO.setRspMsg(NlsProcessBizEnums.RspInfoEnum.SUCCESS.getRspMsg());
					// 设置流程状态
					nlsApplyInfoVO.setFlowStatus(FLOW_STATUS_5);
					/** 设置审批状态信息为处理中 01 **/
					nlsApplyInfoVO.setNlsApplyState(NlsApplyInfoEnums.NlsApplyState.DEALING.getKey());
					// 设置执行次数
					nlsApplyInfoVO.setExecuteTime(0);
					/** 最近修改时间 **/
					nlsProcessBizVo.setLastModifyTime(DateUtility.getCurrAppDateTimeString());
					/** 最近修改时间 **/
					nlsApplyInfoVO.setLastModifyTime(DateUtility.getCurrAppDateTimeString());
					nlsProcessBizService.updateByPk(nlsProcessBizVo);
					nlsApplyInfoService.updateByPk(nlsApplyInfoVO);
					producerService.sendMsg(new Message(TopicEnums.LOANRELEASEORREPAY_QUEUE_TASK_TOPIC.getTopicId(), TagEnums.LOANRELEASEORREPAY_QUEUE_TASK.getTagId(),
							nlsApplyInfoVO.getApplySeq().concat(".").concat(LoanReleaseOrRepayQueueHangHandle.NLSAPPLYINFOVO + nlsApplyInfoVO.getExecuteTime()),
							JSON.toJSONString(nlsApplyInfoVO).getBytes("UTF-8")));
				} else if (exception instanceof LoanRepaySyncException) {
					logger.info("申请流水号 : 【" + applySeq + "】 贷款开立后执行同步任务失败,转为定时器中执行同步任务");
					/** 设置插槽结果信息 **/
					nlsApplyInfoVO.setSoltResultDetails(JSONObject.toJSONString(nlsProcessBizVo));
					/** 设置规则结果信息 **/
					nlsApplyInfoVO.setRuleResultDetails(JSONObject.toJSONString(nlsProcessRuleVO));
					//设置结果码
					nlsApplyInfoVO.setRspCode(NlsProcessBizEnums.RspInfoEnum.SUCCESS.getRspCode());
					//设置结果信息
					nlsApplyInfoVO.setRspMsg(NlsProcessBizEnums.RspInfoEnum.SUCCESS.getRspMsg());
					// 设置流程状态
					nlsApplyInfoVO.setFlowStatus(FLOW_STATUS_8);
					/** 设置审批状态信息为处理中 01 **/
					nlsApplyInfoVO.setNlsApplyState(NlsApplyInfoEnums.NlsApplyState.DEALING.getKey());
					/** 最近修改时间 **/
					nlsApplyInfoVO.setLastModifyTime(DateUtility.getCurrAppDateTimeString());
					nlsApplyInfoService.updateByPk(nlsApplyInfoVO);

				} else {
					logger.info("申请流水号 : 【" + applySeq + "处理该插槽的其它异常开始，更新该插槽状态为失败， 更新网贷任务队列中队列任务状态为执行失败和更新 申请进件信息中申请状态为拒绝");
					// 更新该插槽状态为失败
					methodSoltstate.invoke(nlsProcessBizVo, PrdAdaptedSoltEnums.SoltProcessStateEnum.FAILURE.getCode());
					nlsProcessBizVo.setHangTimes(hangTimes);
					nlsProcessBizVo.setQueueTaskState(QueueTaskEnums.QueueTaskStateEnum.FAILURE.getCode());
					/** 设置插槽结果信息 **/
					nlsApplyInfoVO.setSoltResultDetails(JSONObject.toJSONString(nlsProcessBizVo));
					/** 设置规则结果信息 **/
					nlsApplyInfoVO.setRuleResultDetails(JSONObject.toJSONString(nlsProcessRuleVO));
					/** 设置结果码 **/
					nlsApplyInfoVO.setRspCode(NlsProcessBizEnums.RspInfoEnum.FAILURE.getRspCode());
					/** 设置结果信息 **/
					nlsApplyInfoVO.setRspMsg(NlsProcessBizEnums.RspInfoEnum.FAILURE.getRspMsg());
					/** 设置审批状态信息为失败 **/
					nlsApplyInfoVO.setNlsApplyState(MsLoanConstant.NlsApplyStateEnum.REJECT.getVALUE());
					// 通知审批失败
					noticeMSIfNecessary(nlsProcessBizVo,nlsApplyInfoVO);
					logger.info("申请流水号 : 【" + applySeq + "处理该插槽的其它异常结束");
				}
				/** 设置结果信息 **/
				nlsApplyInfoVO.setRefuseCause(exception.getMessage());

				nlsProcessBizVo.setLastModifyTime(DateUtility.getCurrAppDateTimeString());// 最近修改时间
				// 最近修改时间
				nlsApplyInfoVO.setLastModifyTime(DateUtility.getCurrAppDateTimeString());// 最近修改时间

				nlsProcessBizService.updateByPk(nlsProcessBizVo);
				nlsApplyInfoService.updateByPk(nlsApplyInfoVO);

				throw exception;
			} else {
				logger.info("申请流水号 : 【" + applySeq + "该插槽的无异常开始，更新该插槽状态为成功，此处队列任务表和进件申请表的数据需要等插槽全部执行完成后才更新");
				// 更新该插槽状态为成功
				methodSoltstate.invoke(nlsProcessBizVo, PrdAdaptedSoltEnums.SoltProcessStateEnum.SUCCESS.getCode());
				nlsProcessBizVo.setHangTimes(QueueTaskEnums.QueueHangTimesEnum.INITIALIZE.getTimes());
				// 此处队列任务表和进件申请表的数据需要等插槽全部执行完成后才更新
				logger.info("申请流水号 : 【" + applySeq + "该插槽的无异常结束");
			}
			nlsProcessBizVo.setLastModifyTime(DateUtility.getCurrAppDateTimeString());// 最近修改时间
			// 最近修改时间
			//nlsProcessBizService.updateByPk(nlsProcessBizVo);
		} catch (HangException e) {
			logger.error("队列插槽服务中申请流水号:【" + applySeq + "】的处理挂起异常信息为：" + e.getMessage());
			throw new HangException();
		} catch (BizException e) {
			logger.error("队列插槽服务中申请流水号:【" + applySeq + "】的业务异常信息为：" + e.getMessage());
			throw new BizException();
		} catch (Exception e) {
			logger.error("队列插槽服务中申请流水号:【" + applySeq + "】的其他异常信息为：" + e.getMessage());
			throw new Exception();
		}

	}

	/**
	 * 供插槽实现的抽象方法
	 *
	 *            队列事件
	 * @author huangwb
	 * @since 2019年1月4日 下午5:37:21
	 * @version 1.0
	 */
	protected abstract void doExecute(NlsProcessBizVO nlsProcessBizVo, NlsApplyInfoVO nlsApplyInfoVO) throws Exception;

	/**
	 * @description:通知审批失败
	 * @param nlsProcessBizVo
	 * @date:2019年1月10日 下午2:50:21
	 * @author:hengyh
	 * @throws Exception
	 */
	private void noticeMSIfNecessary(NlsProcessBizVO nlsProcessBizVo,NlsApplyInfoVO nlsApplyInfoVo) throws Exception {
		try {
			if (nlsProcessBizVo.getPrdId().equals(PrdBizEnums.PrdCodeEnum.PRD_CODE_MS.getValue())) {//马上
				MsLoanReq msLoanReq = new MsLoanReq();
				msLoanReq.setTxnFlowNo(nlsProcessBizVo.getApplySeq());// 交易流水号
				msLoanReq.setAudRslt(MsLoanConstant.AudRsltEnum.REJECT.VALUE);
				if (nlsProcessBizVo.getRefuseMsg() == null || nlsProcessBizVo.getRefuseMsg().equals("")) {
					msLoanReq.setRfsRsn(MSRefuseMsgConstant.RESULT_999);//其他原因
				} else {
					msLoanReq.setRfsRsn(nlsProcessBizVo.getRefuseMsg());
				}
				/*msLoanService.msLoan(msLoanReq);// 发送请求*/
			}
			
			if (nlsProcessBizVo.getPrdId().equals(PrdBizEnums.PrdCodeEnum.PRD_CODE_MYD.getValue()) 
					|| nlsProcessBizVo.getPrdId().equals(PrdBizEnums.PrdCodeEnum.PRD_CODE_ZXD.getValue())) {//百度
				LetterReq letterReq = new LetterReq();
				LetterMessage letterMessage = new LetterMessage();
				LetterBasicInfo letterBasicInfo = new LetterBasicInfo();
				LetterExpanding letterExpanding = new LetterExpanding();
				letterReq.setProdCd(nlsApplyInfoVo.getPrdCode());//产品代码
				letterReq.setRqsFlg(nlsApplyInfoVo.getBdReqSn());//请求方需要保证永远唯一 响应方据此判断是否重复请求
				letterReq.setRetCd(MsLoanConstant.RetCodeEnum.SUCCESS.VALUE);
				letterReq.setTxnMd("async");//交易模式
				letterReq.setRepeatRqsBss(nlsApplyInfoVo.getBdReqSn());//重复请求依据
				/** Message	业务数据 start */
				letterMessage.setSessionId(nlsApplyInfoVo.getApplySeq());// 交易流水号
				letterMessage.setEvTp("transaction");//事务类型
				letterMessage.setEvID(nlsApplyInfoVo.getBdTransactionId());//事务ID
				letterMessage.setRqsTmstmp(new Date().getTime()+"");//时间戳
				/** BasicInfo	基本信息 start */
				letterBasicInfo.setIDCertNo(nlsApplyInfoVo.getCertCode());//身份证号
				letterBasicInfo.setBankCardNo(nlsApplyInfoVo.getRecvAcctNo());//银行卡号
				letterBasicInfo.setCustNm(nlsApplyInfoVo.getCusName());//客户姓名
				letterBasicInfo.setMblNo(nlsApplyInfoVo.getMobile());//手机号码
				/** BasicInfo	基本信息 end */
				/** Expanding	定制域 start */
				letterExpanding.setInstRsnCd(nlsApplyInfoVo.getBdReasonCode());	//机构原因码
				letterExpanding.setInstRsnCdRmk(nlsApplyInfoVo.getBdReasonMsg());	//机构原因码说明
				letterExpanding.setInstPolcyCd(MsLoanConstant.RisCodeEnum.FAILURE.VALUE);	//机构策略码
				/** Expanding	定制域 end */
				letterMessage.setBasicInfo(letterBasicInfo);
				letterMessage.setExpanding(letterExpanding);
				letterReq.setMessage(letterMessage);
			/*	letterService.letterNotify(letterReq);// 发送请求*/
			}
		} catch (Exception e) {
			logger.error(e.getMessage());
		}
	}

    @Autowired
    @Qualifier("nlsQueueTaskService")
    private NlsQueueTaskService nlsQueueTaskService;
    @Autowired
    @Qualifier("nlsProcessBizService")
    private NlsProcessBizService nlsProcessBizService;
    @Autowired
    @Qualifier("nlsApplyInfoService")
    private NlsApplyInfoService nlsApplyInfoService;
  /*  @Autowired
    @Qualifier("msLoanService")
    private MsLoanService msLoanService;*/
    @Autowired
    @Qualifier("nlsProcessRuleService")
    private NlsProcessRuleService nlsProcessRuleService;
    @Autowired
    @Qualifier("producerService")
    private MQProducerMessageClient producerService;
 /*   @Autowired
    @Qualifier("letterService")
    private LetterService letterService;*/
    @Autowired
    @Qualifier("nlsQueueSoltComnService")
    private NlsQueueSoltComnService nlsQueueSoltComnService;
    @Autowired
    @Qualifier("updateLmtPrdContService")
    private UpdateLmtPrdContService updateLmtPrdContService;
}
